home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / MacApp Release 10 / MacApp Release 10 - HD Ready / Libraries / Framework / Sources / UViewServer.cp < prev    next >
Encoding:
Text File  |  1996-04-03  |  16.4 KB  |  622 lines  |  [TEXT/MPS ]
  1. //----------------------------------------------------------------------------------------
  2. // UViewServer.cp
  3. // Copyright © 1987-96 by Apple Computer, Inc. All rights reserved.
  4. //----------------------------------------------------------------------------------------
  5.  
  6. #ifndef __UVIEWSERVER__
  7. #include "UViewServer.h"
  8. #endif
  9.  
  10. // MacApp
  11.  
  12. #ifndef __UADORNERS__
  13. #include "UAdorners.h"
  14. #endif
  15.  
  16. //    #ifndef __UAPPLICATION__
  17. //    #include "UApplication.h"
  18. //    #endif
  19.  
  20. #ifndef __UCOREGLOBALS__
  21. #include "UCoreGlobals.h"
  22. #endif
  23.  
  24. #ifndef __UCOREUTILITIES__
  25. #include "UCoreUtilities.h"
  26. #endif
  27.  
  28. #ifndef __UDEBUG__
  29. #include "UDebug.h"
  30. #endif
  31.  
  32. #ifndef __UDISPATCHER__
  33. #include "UDispatcher.h"
  34. #endif
  35.  
  36. //    #ifndef __UERRORMGR__
  37. //    #include "UErrorMgr.h"
  38. //    #endif
  39.  
  40. #ifndef __UGEOMETRY__
  41. #include "UGeometry.h"
  42. #endif
  43.  
  44. #ifndef __UMACAPPGLOBALS__
  45. #include "UMacAppGlobals.h"
  46. #endif
  47.  
  48. #ifndef __UMACAPPUTILITIES__
  49. #include "UMacAppUtilities.h"
  50. #endif
  51.  
  52. #ifndef __UMEMORY__
  53. #include "UMemory.h"
  54. #endif
  55.  
  56. #ifndef __USCROLLER__
  57. #include "UScroller.h"
  58. #endif
  59.  
  60. #ifndef __USTREAM__
  61. #include "UStream.h"
  62. #endif
  63.  
  64. #ifndef __UWINDOW__
  65. #include "UWindow.h"
  66. #endif
  67.  
  68. // Toolbox
  69.  
  70. #ifndef __RESOURCES__
  71. #include <Resources.h>
  72. #endif
  73.  
  74. // ANSI
  75.  
  76. #ifndef __STDIO__
  77. #include <stdio.h>
  78. #endif
  79.  
  80.  
  81. //----------------------------------------------------------------------------------------
  82. // global declarations for globals defined in interface
  83. TViewServer* gViewServer;
  84.  
  85.  
  86. //========================================================================================
  87. // CLASS TViewServer
  88. //========================================================================================
  89. #undef Inherited
  90. #define Inherited TObject
  91.  
  92. #pragma segment MAInit
  93. MA_DEFINE_CLASS_M1(TViewServer, Inherited);
  94.  
  95. //----------------------------------------------------------------------------------------
  96. // TViewServer::TViewServer: Empty constructor to satisfy the compiler.
  97. //----------------------------------------------------------------------------------------
  98. #pragma segment ConstructorRes
  99.  
  100. TViewServer::TViewServer()
  101. {
  102. } // TViewServer::TViewServer
  103.  
  104. //----------------------------------------------------------------------------------------
  105. // TViewServer::IViewServer: 
  106. //----------------------------------------------------------------------------------------
  107. #pragma segment MAInit
  108.  
  109. void TViewServer::IViewServer()
  110. {
  111.     this->IObject();
  112.  
  113.     gViewServer = this;                            // set the global reference.
  114. } // TViewServer::IViewServer 
  115.  
  116. //----------------------------------------------------------------------------------------
  117. // TViewServer::Free: 
  118. //----------------------------------------------------------------------------------------
  119. #pragma segment MAClose
  120.  
  121. TViewServer::~TViewServer()
  122. {
  123.     gViewServer = NULL;                            // NULL out the global reference.
  124. } // TViewServer::Free 
  125.  
  126. //----------------------------------------------------------------------------------------
  127. // TViewServer::NewPaletteWindow: 
  128. //----------------------------------------------------------------------------------------
  129. #pragma segment MAOpen
  130.  
  131. TWindow* TViewServer::NewPaletteWindow(ResNumber itsRsrcID,
  132.                                        Boolean wantHScrollBar,
  133.                                        Boolean wantVScrollBar,
  134.                                        TDocument* itsDocument,
  135.                                        TView* itsMainView,
  136.                                        TView* itsPaletteView,
  137.                                        short sizePalette,
  138.                                        VHSelect whichWay)
  139.  
  140. {
  141.     // create the window, adjust its resize limits, and add the palette view
  142.     MAVolatileInit(TWindow*, aWindow, NewTWindow(itsRsrcID, itsDocument));
  143.     (aWindow->fResizeLimits[topLeft])[whichWay] += sizePalette;
  144.     aWindow->AddSubView(itsPaletteView);
  145.  
  146.     // calculate location of itsMainView
  147.     VPoint itsLocation = gZeroVPt;
  148.     itsLocation[whichWay] = sizePalette;
  149.  
  150.     // add itsMainView to the window with optional scroller
  151.     FailInfo fi;
  152.     Try(fi)
  153.     {
  154.         this->AddSubViewWithScroller(aWindow, itsMainView, wantHScrollBar, wantVScrollBar, itsLocation);
  155.  
  156.         fi.Success();
  157.     }
  158.     else // Recover
  159.     {
  160.         aWindow = (TWindow *)FreeIfObject(aWindow);
  161.  
  162.         fi.ReSignal();                        // Optional. Omit to continue.
  163.     }
  164.  
  165.     return aWindow;
  166. } // TViewServer::NewPaletteWindow 
  167.  
  168. //----------------------------------------------------------------------------------------
  169. // TViewServer::NewSimpleWindow: 
  170. //----------------------------------------------------------------------------------------
  171. #pragma segment MAOpen
  172.  
  173. TWindow* TViewServer::NewSimpleWindow(ResNumber itsRsrcID,
  174.                                       Boolean wantHScrollBar,
  175.                                       Boolean wantVScrollBar,
  176.                                       TDocument* itsDocument,
  177.                                       TView* itsView)
  178.  
  179. {
  180.     // create the window
  181.     MAVolatileInit(TWindow*, aWindow, NewTWindow(itsRsrcID, itsDocument));
  182.  
  183.     // add itsView to the window with optional scroller
  184.     FailInfo fi;
  185.     Try(fi)
  186.     {
  187.         this->AddSubViewWithScroller(aWindow, itsView, wantHScrollBar, wantVScrollBar, gZeroVPt);
  188.  
  189.         fi.Success();
  190.     }
  191.     else // Recover
  192.     {
  193.         aWindow = (TWindow *)FreeIfObject(aWindow);
  194.  
  195.         fi.ReSignal();                        // Optional. Omit to continue.
  196.     }
  197.  
  198.     return aWindow;
  199. } // TViewServer::NewSimpleWindow 
  200.  
  201. //----------------------------------------------------------------------------------------
  202. // TViewServer::AddSubViewWithScroller: 
  203. //----------------------------------------------------------------------------------------
  204. #pragma segment MAOpen
  205.  
  206. void TViewServer::AddSubViewWithScroller(TWindow* aWindow,
  207.                                          TView* itsView,
  208.                                          Boolean wantHScrollBar,
  209.                                          Boolean wantVScrollBar,
  210.                                          const VPoint& itsLocation)
  211. {
  212.     TScroller * aScroller = NULL;
  213.     
  214.     if (wantHScrollBar || wantVScrollBar)
  215.     {
  216.         // calculate scroller's dimensions
  217.         VRect sBarOffsets = gZeroVRect;
  218.         VPoint itsSize = aWindow->fSize;
  219.         
  220.         // Account for scroller _not_ being located at VPoint (0,0)
  221.         // as when a palette is sharing the window.
  222.         itsSize -= itsLocation;
  223.             
  224.         if (wantHScrollBar)
  225.         {
  226.             itsSize.v -= kSBarSizeMinus1;
  227.             if (!wantVScrollBar)
  228.                 sBarOffsets.right = -kSBarSizeMinus1;
  229.         }
  230.         if (wantVScrollBar)
  231.         {
  232.             itsSize.h -= kSBarSizeMinus1;
  233.             if (!wantHScrollBar)
  234.                 sBarOffsets.bottom = -kSBarSizeMinus1;
  235.         }
  236.  
  237.         // create the scroller
  238.         aScroller = new TScroller;
  239.         aScroller->IScroller(aWindow, itsLocation, itsSize, sizeRelSuperView, sizeRelSuperView, gZeroVPt, wantHScrollBar, wantVScrollBar);
  240.         aScroller->fSBarOffsets = sBarOffsets;
  241.     }
  242.  
  243.     // add the subview
  244.     if (aScroller)
  245.         aScroller->AddSubView(itsView);
  246.     else
  247.         aWindow->AddSubView(itsView);
  248.  
  249.     aWindow->SetWindowTarget(itsView);
  250.  
  251.     // make sure window and subviews are the right size 
  252.     aWindow->Resize(((CRect &) GetWindowPort(aWindow->fWMgrWindow)->portRect).GetSize(), kDontInvalidate);
  253. } // TViewServer::AddSubViewWithScroller 
  254.  
  255. //----------------------------------------------------------------------------------------
  256. // TViewServer::NewTWindow: 
  257. //----------------------------------------------------------------------------------------
  258. #pragma segment MAOpen
  259.  
  260. TWindow* TViewServer::NewTWindow(ResNumber itsRsrcID,
  261.                                  TDocument* itsDocument)
  262.  
  263. {
  264.     TWindow * aWindow = NULL;
  265.     Boolean canResize;
  266.     Boolean canClose;
  267.  
  268.     WindowRef storage = NULL;
  269. #if !STRICT_WINDOWS    
  270.     storage = (WindowRef)new CWindowRecord;
  271. #endif
  272.  
  273.     MAVolatileInit(WindowRef, aWMgrWindow, gDispatcher->NewToolboxWindow((Ptr)storage, itsRsrcID, canResize, canClose));
  274.     // NewToolboxWindow signals Failure 
  275.  
  276.     FailInfo fi;
  277.     Try(fi)
  278.     {
  279.         aWindow = new TWindow;
  280.         fi.Success();
  281.     }
  282.     else // Recover
  283.     {
  284.         aWMgrWindow = TWindow::FreeIfWMgrWindow(aWMgrWindow, storage == NULL);
  285.         fi.ReSignal();
  286.     }
  287.  
  288.     // !STRICT_WINDOWS (FALSE) means TWindow can't dispose wmgr window when freed, just CloseWindow.
  289.     aWindow->IWindow(itsDocument, aWMgrWindow, canResize, canClose, !STRICT_WINDOWS);
  290.  
  291.     return aWindow;
  292. } // TViewServer::NewTWindow 
  293.  
  294. //----------------------------------------------------------------------------------------
  295. // TViewServer::NewTemplateWindow: 
  296. //----------------------------------------------------------------------------------------
  297. #pragma segment MAOpen
  298.  
  299. TWindow* TViewServer::NewTemplateWindow(ResNumber viewRsrcID,
  300.                                         TDocument* itsDocument)
  301.  
  302. {
  303.     TWindow    *theWindow = NULL;
  304.     TView *aView = NULL;
  305.     
  306.     MAVolatileInit(TView*,theTarget,NULL);
  307.     
  308.     FailInfo fi;
  309.     Try(fi)
  310.     {
  311.         aView = this->DoCreateViews(itsDocument, NULL, viewRsrcID, gZeroVPt);
  312.         if (aView)
  313.         {
  314. #if qDebug
  315.             if (!(aView->DescendsFrom(TWindow::GetClassDescStatic())))
  316.                 ProgramBreak("In NewTemplateWindow: Root view is not a window");
  317. #endif
  318.             theWindow = (TWindow *)aView;
  319.     
  320.             if (theWindow->fTargetID != kNoIdentifier)
  321.             {
  322.                 theTarget = theWindow->FindSubView(theWindow->fTargetID);
  323.                 if (theTarget)
  324.                 {
  325.                     theWindow->SetWindowTarget(theTarget);
  326.                 }
  327. #if qDebug
  328.                 else
  329.                 {
  330.                     CStr255        errString("TViewServer::NewTemplateWindow:\n  The window's indicated target view cannot be found.\n");
  331.                     errString += "  Unable to find view with fTargetID: '" + CStr255(theWindow->fTargetID) + "'.";
  332.                     ProgramBreak(errString);
  333.                 }
  334. #endif
  335.             }
  336.             fi.Success();
  337.         }
  338.     }
  339.     else // recover
  340.     {
  341.         aView = (TView*)FreeIfObject(aView);
  342.         fi.ReSignal();
  343.     }
  344.     return theWindow;
  345. } // TViewServer::NewTemplateWindow 
  346.  
  347. //----------------------------------------------------------------------------------------
  348. // TViewServer::ReadViewsFromResource: 
  349. //----------------------------------------------------------------------------------------
  350. #pragma segment MAOpen
  351.  
  352. TView* TViewServer::ReadViewsFromResource(TDocument* /* itsDocument */,
  353.                                           TView* parentView,
  354.                                           ResNumber itsRsrcID,
  355.                                           const VPoint& subviewOffset)
  356.  
  357. {
  358.     MAVolatileInit(TView*, firstView, NULL);                    // Assume the worst. 
  359.     MAVolatileInit(TStream*, itsViewStream, NULL);
  360.  
  361.     FailInfo fi;
  362.     Try(fi)
  363.     {
  364.         itsViewStream = this->DoMakeViewStream(itsRsrcID, NULL);
  365.  
  366.         short numViews = itsViewStream->ReadInteger();
  367.  
  368.         if (numViews == kMAThreeOhTemplateVersion)// actually, the view template version
  369.         {
  370.             firstView = this->ReadViewsFrom(itsViewStream, parentView, subviewOffset);// the new protocol
  371.         }
  372.         else
  373.         {
  374.             ProgramBreak("Incompatible version of 'View' resources");
  375.         }
  376.         fi.Success();
  377.     }
  378.     else // Recover
  379.     {
  380.         // set position so that when the view stream frees itself, 
  381.         // it won't truncate the handle (see THandleStream::Free)
  382.         // If it did truncate the handle, we'd have no hope of ever
  383.         // re-reading this 'View'
  384.         if (itsViewStream != NULL)
  385.         {
  386.             itsViewStream->SetPosition(itsViewStream->GetSize());
  387.         }
  388.         itsViewStream = (TStream *)FreeIfObject(itsViewStream);
  389.         firstView = (TView *)FreeIfObject(firstView);
  390.         fi.ReSignal();
  391.     }
  392.  
  393.     itsViewStream = (TStream *)FreeIfObject(itsViewStream);
  394.  
  395.     return firstView;
  396. } // TViewServer::ReadViewsFromResource 
  397.  
  398. //----------------------------------------------------------------------------------------
  399. // TViewServer::ReadViewsFrom: 
  400. //----------------------------------------------------------------------------------------
  401. #pragma segment MAOpen
  402.  
  403. TView* TViewServer::ReadViewsFrom(TStream* itsStream,
  404.                                   TView* parentView,
  405.                                   const VPoint& subviewOffset)
  406. {
  407.     //MAVolatileInit(TView*, aView, NULL);
  408.     TView* aView = NULL;    // can't be volatile because it is passed by reference
  409.  
  410.     FailInfo fi;
  411.     Try(fi)
  412.     {
  413.         itsStream->ReadStreamObject((TObject * &)aView);
  414.         if (aView)
  415.         {
  416.             if (parentView)
  417.             {
  418.                 parentView->AddSubView(aView);
  419.             }
  420.             
  421.             if (subviewOffset != gZeroVPt)
  422.             {
  423.                 aView->Locate(aView->fLocation + subviewOffset, kDontInvalidate);
  424.             }
  425.         }
  426. #if qDebugMsg
  427.         else
  428.             ProgramBreak("###Unknown TView in TViewServer::ReadViewsFrom.");
  429. #endif
  430.  
  431.         fi.Success();
  432.     }
  433.     else // Recover
  434.     {
  435.         aView = (TView *)FreeIfObject(aView);
  436.         fi.ReSignal();
  437.     }
  438.  
  439.     return aView;
  440. } // TViewServer::ReadViewsFrom 
  441.  
  442. //----------------------------------------------------------------------------------------
  443. // TViewServer::DoCreateViews: 
  444. //----------------------------------------------------------------------------------------
  445. #pragma segment MAOpen
  446.  
  447. TView* TViewServer::DoCreateViews(TDocument* itsDocument,
  448.                                   TView* parentView,
  449.                                   ResNumber itsRsrcID,
  450.                                   const VPoint& subviewOffset)
  451. {
  452.     TView * rootView = this->ReadViewsFromResource(itsDocument, parentView, itsRsrcID, subviewOffset);
  453.     if (rootView)
  454.     {
  455.         FailInfo fi;
  456.         Try(fi)
  457.         {
  458.             rootView->HandlePostCreate(itsDocument);
  459.             fi.Success();
  460.         }
  461.         else // Recover
  462.         {
  463.             rootView->Free();
  464.             fi.ReSignal();
  465.         }
  466.         rootView->AdjustFrame();                // Make sure size gets adjusted by the size determiners 
  467.     }
  468.     return rootView;
  469. } // TViewServer::DoCreateViews 
  470.  
  471. //----------------------------------------------------------------------------------------
  472. // TViewServer::DoMakeViewStream: 
  473. //----------------------------------------------------------------------------------------
  474. #pragma segment MAOpen
  475.  
  476. TStream* TViewServer::DoMakeViewStream(ResNumber itsRsrcID,
  477.                                        Handle itsHandle)
  478. {
  479.     Handle viewStreamHandle;
  480.     MAVolatileInit(THandleStream*, itsViewStream, NULL);
  481.     MAVolatileInit(TContext*, itsContext, NULL);
  482.  
  483.     if (itsHandle)
  484.         viewStreamHandle = itsHandle;
  485.     else
  486.     {
  487.         // Try to get a new 'View' resource first.  If not found, then get a 'view' resource.
  488.         viewStreamHandle = GetResource('View', itsRsrcID);
  489. #if qDebug
  490.         if (!viewStreamHandle)
  491.         {
  492.             viewStreamHandle = GetResource('view', itsRsrcID);
  493.             if (viewStreamHandle)
  494.             {
  495.                 ProgramBreak("Use ViewPromoter. Program contains 2.0 'view' resources");
  496.                 ReleaseResource(viewStreamHandle);
  497.                 viewStreamHandle = NULL;
  498.             }
  499.         }
  500. #endif
  501.  
  502.         FailNILResource(viewStreamHandle);
  503.     }
  504.  
  505.     itsViewStream = new THandleStream;
  506.     itsViewStream->IHandleStream(viewStreamHandle, sizeof(long));
  507.  
  508.     FailInfo fi;
  509.     Try(fi)
  510.     {
  511.         Boolean newEntry;
  512.         
  513.         itsContext = new TContext;
  514.         itsContext->IContext();
  515.         itsContext->Add(gDimAdorner, kDontForceReplacement, newEntry);
  516.         itsContext->Add(gDrawAdorner, kDontForceReplacement, newEntry);
  517.         itsContext->Add(gEraseAdorner, kDontForceReplacement, newEntry);
  518.         itsContext->Add(gHiliteAdorner, kDontForceReplacement, newEntry);
  519.         itsContext->Add(gPrintAdorner, kDontForceReplacement, newEntry);
  520.         itsContext->Add(gResizeIconAdorner, kDontForceReplacement, newEntry);
  521.         itsContext->Add(gSelectionAdorner, kDontForceReplacement, newEntry);
  522.         
  523.         fi.Success();
  524.     }
  525.     else // Recover
  526.     {
  527.         itsViewStream = (THandleStream *)FreeIfObject(itsViewStream);
  528.         fi.ReSignal();
  529.     }
  530.  
  531.     if (itsContext)
  532.         itsViewStream->SetContext(itsContext);
  533.  
  534.     return itsViewStream;
  535. } // TViewServer::DoMakeViewStream 
  536.  
  537. //----------------------------------------------------------------------------------------
  538. // TViewServer::WriteViewsToResource: 
  539. //----------------------------------------------------------------------------------------
  540. #pragma segment MAWriteResource
  541.  
  542. void TViewServer::WriteViewsToResource(TView* view,
  543.                                        ResNumber itsRsrcID,
  544.                                        const CStr255& name,
  545.                                        short resourceAttributes)
  546. {
  547.     MAVolatileInit(Handle, viewHandle, NULL);
  548.  
  549. #if qDebugMsg
  550.     if ((viewHandle = Get1Resource('View', itsRsrcID)) != NULL)
  551.         fprintf(stderr, "###TViewServer::WriteViewsToResource warning: About to over-write 'View' resource id %d.\n", itsRsrcID);
  552. #endif
  553.  
  554.     viewHandle = this->WriteViewsToHandle(view);// write the views to the handle
  555.     FailNIL(viewHandle);
  556.  
  557.     FailInfo fi;
  558.     Try(fi)
  559.     {
  560.         AddResource(viewHandle, 'View', itsRsrcID, name);// add the handle as a resource
  561.         FailResError();
  562.         fi.Success();
  563.     }
  564.     else // Recover
  565.     {
  566.         viewHandle = DisposeIfHandle(viewHandle);
  567.         fi.ReSignal();
  568.     }
  569.  
  570.     SetResAttrs(viewHandle, resourceAttributes);// set the resource attributes
  571.     FailResError();
  572.  
  573.     // Need the following ChangedResource call because the SetResAttrs call on the previous
  574.     // line cleared the "resChanged" attribute of the resource.
  575.     ChangedResource(viewHandle);
  576.     FailResError();
  577.     
  578. } // TViewServer::WriteViewsToResource 
  579.  
  580. //----------------------------------------------------------------------------------------
  581. // TViewServer::WriteViewsToHandle: 
  582. //----------------------------------------------------------------------------------------
  583. #pragma segment MAWriteResource
  584.  
  585. Handle TViewServer::WriteViewsToHandle(TView* view)
  586. {
  587.     MAVolatileInit(Handle, aHandle, NULL);
  588.     MAVolatileInit(TStream*, itsViewStream, NULL);
  589.  
  590.     FailInfo fi;
  591.     Try(fi)
  592.     {
  593.         short numViews = 0;
  594.  
  595.         aHandle = NewPermHandle(kViewRsrcExpandAmt);// create a handle for the stream
  596.  
  597.         itsViewStream = this->DoMakeViewStream(kNoResource, aHandle);
  598.  
  599.         itsViewStream->WriteInteger(kMAThreeOhTemplateVersion);// Write version number
  600.  
  601.         itsViewStream->WriteStreamObject(view, kStandardObject);
  602.  
  603.         itsViewStream->Free();
  604.  
  605.         fi.Success();
  606.     }
  607.     else // Recover
  608.     {
  609.         itsViewStream = (TStream *)FreeIfObject(itsViewStream);
  610.         aHandle = DisposeIfHandle(aHandle);
  611.  
  612.         fi.ReSignal();
  613.     }
  614.  
  615.     return aHandle;                                // return the handle
  616. } // TViewServer::WriteViewsToHandle 
  617.  
  618. //----------------------------------------------------------------------------------------
  619. // End of UViewServer.cp
  620.  
  621. #pragma segment Inline
  622.